#include <mips/regdef.h>
#include <sys/syscall.h>
	.text
	.align	2
	.globl	linecmp
	.ent	linecmp
linecmp:
    .frame $fp,24,ra    #LTA=8; SRA=16(gp,fp y ra),ABA=0(leaf)
    .set noreorder
    .cpload t9
    .set reorder
    subu sp,sp,24
    .cprestore 8        #sw gp,8(sp)
#   sw  gp,8(sp)
    sw  $fp,12(sp)
    sw  ra,16(sp)
    move $fp,sp
# guardo los argumentos en ABA
    sw  a0,24($fp)      #line1
    sw  a1,28($fp)      #line2
    li  t0,97           #a='a', ascii(a)=97
    sw  t0,0($fp)
    li  t1,98           #b='b', ascii(b)=98
    sw  t1,4($fp)
while_sort:
    li  t2,10           #'\n'=10

    lw  t0,0($fp)       #cargo a
    beq t0,t2,while_sort_end # a=='\n'

    lw  t1,4($fp)       #cargo b
    beq t1,t2,while_sort_end # b=='\n'

    lw  t2,24($fp)      #line1
    lw  t0,0(t2)        
    sw  t0,0($fp)       #a=line1
    addiu t2,t2,4       #line1++
    sw  t2,24($fp)      

    lw  t3,28($fp)      #line2
    lw  t1,0(t3)        
    sw  t1,4($fp)       #b=line2 
    addiu t3,t3,4       #line1++
    sw  t3,28($fp) 

    blt t0,t1,salida_menor  #if(a<b)return -1 //line1 es menor
    bgt t0,t1,salida_mayor  #else if (a > b) return 1; //line2 es menor
    b while_sort

while_sort_end:
iguales:
    lw  t0,0($fp)       #cargo a
    li  t2,10           #'\n'=10
    bne t0,t2,iguales_fin
    lw  t1,4($fp)       #cargo b
    bne t1,t2,iguales_fin
    li  v0,0
    b   salida
iguales_fin:
    lw  t0,0($fp)
    li  t2,10
    bne t0,t2,salida_mayor
salida_menor:
    li  v0,-1
    b   salida
salida_mayor:
    li  v0,1
    b   salida
salida:
    move sp,$fp
    lw  gp,8(sp)
    lw  $fp,12( sp)
    lw  ra,16(sp)
    addu sp,sp,24  
    jr  ra
    .end linecmp
	.size	linecmp, .-linecmp
    .text
    .align 2    
    .global stoogesort
    .ent stoogesort
stoogesort:
    .frame $fp,40,ra    #LTA=8; SRA=16(gp,fp y ra),ABA=16
    .set noreorder
    .cpload t9
    .set reorder
    subu    sp,sp,40
    .cprestore 24
    sw      gp,24(sp)
    sw      $fp,28(sp)
    sw      ra,32(sp)
    move    $fp,sp
    
    sw      a0,40($fp)  # **array
    sw      a1,44($fp)  # int inicio
    sw      a2,48($fp)  # int fin

    lw      t0,40($fp)  # cargo las variables
    lw      t1,44($fp)
    lw      t2,48($fp)  

    sll     t1,t1,2     # multiplico por cuatro, indexo int
    sll     t2,t2,2     # multiplico por cuatro, indexo int

    addu    t1,t1,t0    # lo sumo a la base del array, &array[i]
    addu    t2,t2,t0    # lo sumo a la base del array, &array[j]

    lw      a0,0(t1)    # leo el dato line[i]
    lw      a1,0(t2)    # leo el dato line[j]

    la      t9,linecmp  # linecmp(array[i],array[j])
    jal     ra,t9
    bgtz    v0,swap 
    b       condicion_corte
    
swap:
    lw      t0,40($fp)  # cargo las variables
    lw      t1,44($fp)
    lw      t2,48($fp)  

    sll     t1,t1,2     # multiplico por cuatro, indexo int
    sll     t2,t2,2     # multiplico por cuatro, indexo int

    addu    t1,t1,t0    # lo sumo a la base del array, &array[i]
    addu    t2,t2,t0    # lo sumo a la base del array, &array[j]
    
    lw      t3,0(t1)    # leo el dato line[i]
    lw      t4,0(t2)    # leo el dato line[j]
    
    sw      t3,16($fp)  # temp = line[i]    
    sw      t4,0(t1)    # line[i] = line[j]
    lw      t3,16($fp)  # leo temp
    sw      t3,0(t2)    # line[j] = temp
condicion_corte:
    lw      t1,44($fp)  # i
    lw      t2,48($fp)  # j
    addu    t0,t1,1     # i + 1
    slt     t0,t0,t2    # i+1 < j ? 1 : 0
    bnez    t0,llamadas_recursivas
    b       salida_sort    
llamadas_recursivas:
# k = (int) ((j-i+1)/3);
    addu    t0,t2,1     # t0=j + 1
    subu    t0,t0,t1     # t0 - i
    li      t4,3
    div     t0,t4
    sw      t0,20($fp)  # k
# stoogesort(lines, i, j-k);
    lw      a0,40($fp) #array
    lw      a1,44($fp) #i
    lw      t0,20($fp) #k
    lw      t2,48($fp) #j
    subu    a2,t2,t0   #j-k
    la      t9,stoogesort
    jal     ra,t9	
# stoogesort(lines, i+k, j);
    lw      a0,40($fp)  #array
    lw      t1,44($fp)  # i
    lw      t0,20($fp)  # k
    addu    a1,t1,t0
    lw      a2,48($fp)  # j
    la      t9,stoogesort
    jal     ra,t9
# stoogesort(lines, i, j-k);
    lw      a0,40($fp)
    lw      a1,44($fp)  # i
    lw      t0,20($fp)  # k
    lw      t2,48($fp)  # j
    subu    a2,t2,t0
    la      t9,stoogesort
    jal     ra,t9
salida_sort:
    move    sp,$fp      # recupero el puntero del stack
    lw      ra,32(sp)   # recupero registros salvados
    lw      $fp,28(sp)
    lw      gp,24(sp)  
    addiu    sp,sp,40  # devuelvo la memoria usada para el stack
    jr      ra
    .end stoogesort
    .size stoogesort, .-stoogesort
    

